home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 13 - 1997 (partial) / 13.05 May 97 / TidyHeap / CTidyHeap_AC.cp < prev    next >
Encoding:
Text File  |  1997-04-14  |  30.3 KB  |  1,232 lines  |  [TEXT/MPS ]
  1. //----------------------------------------------------------------------------------------
  2. // CTidyHeap_AC.cp
  3. // Copyright © 1984-97 by Apple Computer, Inc. All rights reserved.
  4. //----------------------------------------------------------------------------------------
  5.  
  6. #ifndef __CTidyHeap_AC__
  7. #include "CTidyHeap_AC.h"
  8. #endif
  9.  
  10. #if qTidyHeap
  11.  
  12. // Toolbox
  13. #ifndef __LOWMEM__
  14. #include <LowMem.h>
  15. #endif
  16. #ifndef __SEGLOAD__
  17. #include <SegLoad.h>
  18. #endif
  19. #ifndef __PROCESSES__
  20. #include <Processes.h>
  21. #endif
  22. #ifndef __TEXTUTILS__
  23. #include <TextUtils.h>
  24. #endif
  25.  
  26. // standard libs
  27. #ifndef _STDARG
  28. #include <stdarg.h>
  29. #endif
  30. #ifndef _STRING
  31. #include <string.h>
  32. #endif
  33. #ifndef _STDIO
  34. #include <stdio.h>
  35. #endif
  36.  
  37. // TidyHeap
  38.  
  39.  
  40. #ifndef __CTidyHeapDebugStrLogger_AC__
  41. #include "CTidyHeapDebugStrLogger_AC.h"
  42. #endif
  43. #ifndef __CTidyHeapAction_AC__
  44. #include "CTidyHeapAction_AC.h"
  45. #endif
  46. #ifndef __CTidyHeapActions_AC__
  47. #include "CTidyHeapActions_AC.h"
  48. #endif
  49. #ifndef __CTidyHeapActionsMore_AC__
  50. #include "CTidyHeapActionsMore_AC.h"
  51. #endif
  52. #ifndef __CTidyHeapActionList_AC__
  53. #include "CTidyHeapActionList_AC.h"
  54. #endif
  55. #ifndef __CTidyHeapBlock_AC__
  56. #include "CTidyHeapBlock_AC.h"
  57. #endif
  58. #ifndef __CTidyHeapBlockList_AC__
  59. #include "CTidyHeapBlockList_AC.h"
  60. #endif
  61. #ifndef __CTidyHeapFile_AC__
  62. #include "CTidyHeapFile_AC.h"
  63. #endif
  64. #ifndef __CTidyHeapLogFileLogger_AC__
  65. #include "CTidyHeapLogFileLogger_AC.h"
  66. #endif
  67. #ifndef __CTidyHeap_ACPRIVATE__
  68. #include "CTidyHeapPrivate_AC.h"
  69. #endif
  70. #ifndef __CTidyHeapState_AC__
  71. #include "CTidyHeapState_AC.h"
  72. #endif
  73.  
  74. #ifndef __CActIncrementalNewFailer_AC__
  75. #include "CActIncrementalNewFailer_AC.h"
  76. #endif
  77.  
  78. // TidyHeapSharedLib
  79.  
  80. #ifndef __TIDYHEAPLIB__
  81. #include "TidyHeapSharedLib.h"
  82. #endif
  83.  
  84.  
  85. static const long kHeaderSize = sizeof(BlockHeader) - sizeof(long);
  86. static const long kTrailerSize = sizeof(BlockTrailer);
  87.  
  88. void* operator new(size_t, void* ptr);
  89.     // for some reason I had to declare this. Hmm.
  90.  
  91. GlobalNewProc         CTidyHeap_AC::GlobalNew;
  92. GlobalDeleteProc      CTidyHeap_AC::GlobalDelete;
  93.  
  94. CTidyHeap_AC* CTidyHeap_AC::fgSelf;
  95.  
  96.  
  97. //========================================================================================
  98. // NEW / DELETE Overrides.
  99. //========================================================================================
  100.  
  101. //----------------------------------------------------------------------------------------
  102. // operator new 
  103. //----------------------------------------------------------------------------------------
  104.     
  105. void* operator new(size_t /*size*/, void* ptr, const char* /*file*/ , short /*lineNum*/)
  106. {
  107.     return ptr;
  108. } 
  109.  
  110. //----------------------------------------------------------------------------------------
  111. // operator new 
  112. //----------------------------------------------------------------------------------------
  113.     
  114. void* operator new(size_t /*size*/, void* ptr)
  115. {
  116.     return ptr;
  117. }
  118.  
  119. //----------------------------------------------------------------------------------------
  120. // operator new 
  121. //----------------------------------------------------------------------------------------
  122.     
  123. void* operator new(size_t size)
  124. {
  125.     CTidyHeap_AC* tidyHeap = CTidyHeap_AC::Instance();
  126.     return tidyHeap->CreateBlock(size, NULL, -1) ;
  127. }
  128.  
  129. //----------------------------------------------------------------------------------------
  130. // operator new 
  131. //----------------------------------------------------------------------------------------
  132.     
  133. void* operator new(size_t size, const char* file, short line)
  134. {
  135.     CTidyHeap_AC* tidyHeap = CTidyHeap_AC::Instance();
  136.     return tidyHeap->CreateBlock(size, file, line);
  137. }
  138.  
  139. //----------------------------------------------------------------------------------------
  140. // operator delete 
  141. //----------------------------------------------------------------------------------------
  142.     
  143. void operator delete(void* ptr )
  144. {
  145.     if(ptr)
  146.     {
  147.         CTidyHeap_AC* tidyHeap = CTidyHeap_AC::Instance();
  148.         tidyHeap->RemoveBlock(ptr);
  149.     }
  150. }        
  151.  
  152. //========================================================================================
  153. // class CTidyHeap_AC
  154. //========================================================================================
  155.  
  156. //----------------------------------------------------------------------------------------
  157. // CTidyHeap_AC constructor
  158. //----------------------------------------------------------------------------------------
  159.          
  160. CTidyHeap_AC::CTidyHeap_AC() 
  161.     :    fCount(0),
  162.         fSizeTally(0),
  163.         fDebugTally(0),
  164.         fDeleteCount(0),
  165.         fErr(0),
  166.         fNextNewFails(false),
  167.         fEnabledOnStart(false),
  168.         fLogger(NULL),
  169.         fSettingsFile(NULL),
  170.         fLineNum(0)
  171. {
  172.     fFileName[0] = '\0';
  173.     fLogString[0] = '\0';
  174. }
  175.  
  176. //----------------------------------------------------------------------------------------
  177. // CTidyHeap_AC ITidyHeap
  178. //----------------------------------------------------------------------------------------
  179.     
  180. void CTidyHeap_AC::ITidyHeap()
  181. {
  182.     SetToLogFileLogger();
  183.  
  184.     fSettingsFile = new CTidyHeapFile_AC;
  185.     if(fSettingsFile)
  186.     {
  187.         fSettingsFile->SetTypeAndCreator(kSettingsFileType, kSettingsFileCreator);
  188.         fSettingsFile->AppendExtension(".prf");
  189.         fSettingsFile->ReadObject( *this );
  190.     }
  191.     
  192.     fEnabledOnStart = fPrefs.TestFlag(kEnabled);
  193.     
  194.     InstallPrefActions();
  195.     
  196.     TIDYHEAPSHAREDLIB_SETCALLBACK( Terminate );
  197. }
  198.  
  199. //----------------------------------------------------------------------------------------
  200. // CTidyHeap_AC destructor
  201. //----------------------------------------------------------------------------------------
  202.  
  203. CTidyHeap_AC::~CTidyHeap_AC()
  204. {
  205.     DeleteActions(fDeleteActions);
  206.     DeleteActions(fNewActions);
  207.     DeleteActions(fTerminationActions);    
  208.     
  209.     fSettingsFile->WriteObject( *this );
  210.     delete fSettingsFile;
  211.     
  212.     if(fLogger) delete fLogger;
  213. }
  214.  
  215. //----------------------------------------------------------------------------------------
  216. // CTidyHeap_AC::GetBlockCount
  217. //----------------------------------------------------------------------------------------
  218.  
  219. long CTidyHeap_AC::GetBlockCount() const
  220. {
  221.     if(fgSelf)
  222.         return fgSelf->fBlockList.GetCount();
  223.     else
  224.         return 0;
  225. }    
  226.  
  227. //----------------------------------------------------------------------------------------
  228. // CTidyHeap_AC::FindTrailer
  229. //----------------------------------------------------------------------------------------
  230.  
  231. BlockTrailer* CTidyHeap_AC::FindTrailer(BlockHeader* inBlock)
  232. {
  233.     BlockTrailer* outPtr = (BlockTrailer*) 
  234.         (((char*)inBlock) + sizeof(BlockHeader) + inBlock->fBlockPtr->fSize - sizeof(long));    
  235.         
  236.     if(outPtr->fMarker3 != kMarker3)
  237.     {
  238.         outPtr = NULL;
  239.         fErr = kBadMarker3;
  240.     }
  241.     
  242.     if(fErr)
  243.     {
  244.         LogError();
  245.     }
  246.  
  247.     return outPtr;
  248. }
  249.  
  250. //----------------------------------------------------------------------------------------
  251. // CTidyHeap_AC::CreateBlock
  252. //----------------------------------------------------------------------------------------
  253.  
  254. void* CTidyHeap_AC::CreateBlock(size_t size, const char* file, short line)
  255. {
  256.     void* outPtr = NULL;
  257.     
  258.     if( !IsEnabled() )
  259.         outPtr = GlobalNew(size);
  260.     else
  261.     {
  262.         fCount++; // this is always incremented.
  263.  
  264.         if(fNextNewFails) 
  265.         {
  266.             fNextNewFails = false;
  267.             
  268.             if(!outPtr)
  269.                 HandleNilAllocation();
  270.         }
  271.         else
  272.         {
  273.         
  274.             BlockHeader* headerPtr = (BlockHeader*) GlobalNew(size + kHeaderSize + kTrailerSize);
  275.             if(headerPtr)
  276.             {
  277.                 
  278.                 CTidyHeapBlock_AC*    blockPtr = CreateBlockObject();
  279.                 if(!blockPtr)
  280.                  {
  281.                     GlobalDelete( (void*) headerPtr );
  282.                 }
  283.                 else
  284.                 {
  285.                     // Setup header
  286.                     new(headerPtr) BlockHeader; // call blocks' constructor
  287.                     
  288.                     // Setup trailer
  289.                     new(((char*)headerPtr) + kHeaderSize + size) BlockTrailer;
  290.                 
  291.                     outPtr = &(headerPtr->fData);
  292.                     fDebugTally += kHeaderSize;
  293.                     fSizeTally += size; 
  294.                     
  295.                     blockPtr->fSize = size;
  296.                     blockPtr->fAddress = outPtr;
  297.                     blockPtr->fHeader = headerPtr;
  298.                     blockPtr->fId = fCount;
  299.                     
  300.                     headerPtr->fBlockPtr = blockPtr;
  301.                     
  302.                     if(file)
  303.                     {
  304.                         ::strcpy( blockPtr->fFile, file );
  305.                         blockPtr->fLineNum = line;
  306.                     }
  307.                     else
  308.                     if(::strlen(fFileName))
  309.                     {
  310.                         ::strcpy( blockPtr->fFile, fFileName );
  311.                         blockPtr->fLineNum = fLineNum;
  312.                         fFileName[0] = '\0';
  313.                         fLineNum = 0;
  314.                     }
  315.                     
  316.                     CTidyHeapAction_AC* action = fNewActions.GetHead();
  317.                     
  318.                     while(action)
  319.                     {
  320.                         DoAction( action, headerPtr );
  321.                         action = action->Next();
  322.                     }
  323.                     
  324.                     if(fNextNewFails)
  325.                     {
  326.                         fNextNewFails = false;
  327.                         delete blockPtr;
  328.                         fgSelf->GlobalDelete(headerPtr);    
  329.                         outPtr = NULL;
  330.                         
  331.                         if(!outPtr)
  332.                             HandleNilAllocation();
  333.                     }
  334.                     else
  335.                     if(!blockPtr->IsExempt())
  336.                     {
  337.                         // exempting a block means don't track it
  338.                         fBlockList.Append(blockPtr);
  339.                     }
  340.                     
  341.                 }
  342.             }
  343.         }
  344.     }    
  345.     return outPtr;
  346. }
  347.  
  348. //----------------------------------------------------------------------------------------
  349. // CTidyHeap_AC::FindHeader
  350. //----------------------------------------------------------------------------------------
  351.  
  352.  
  353. BlockHeader* CTidyHeap_AC::FindHeader(char* inPtr)    
  354. {
  355.     fErr = 0;
  356.     
  357.     BlockHeader* outHeader = NULL;
  358.     
  359.     if(GetFeaturePrefs().TestFlag(kPointersLivesInAppHeap))
  360.     {
  361.         if(!PtrInAppHeap(inPtr))
  362.         {
  363.             fErr = kPtrNotInAppHeap;
  364.         }
  365.     }
  366.     
  367.     if(!fErr)
  368.     {    
  369.         // First place to check for the header is immediately on top of the incoming ptr.
  370.         char* walker = inPtr;
  371.     
  372.         walker -= kHeaderSize;
  373.         
  374.         if(CharPtrToLong(walker) == kMarker1)
  375.         {
  376.             outHeader = (BlockHeader*) walker;
  377.         
  378.             if(outHeader->fMarker2 != kMarker2)
  379.             {
  380.                 outHeader = NULL;
  381.                 
  382.                 fErr = kBadMarker2;
  383.             }    
  384.         }
  385.         else
  386.         {
  387.             // If we get here that means the block is either corrupted
  388.             // or the compiler has padded something. So now were going
  389.             // to search backward for one of our markers.
  390.             
  391.             char* startOfValidMem = (inPtr - kHeaderSize);
  392.                 // I'm assuming that the header is there and that we have a block of mem
  393.                 // at least the sizeof the blockheader to search in. I can't guarentee that
  394.                 // mem at location less that startofValidMem is even there.
  395.                       
  396.             for(walker = inPtr; walker >= startOfValidMem; walker--)
  397.             {
  398.                 if(CharPtrToLong(walker) == kMarker2)
  399.                 {
  400.                     // whoo hoo! We found the footMarker.
  401.                 
  402.                     walker -= sizeof( BlockHeader ) - sizeof(long); 
  403.                     
  404.                     if(CharPtrToLong(walker) == kMarker1)
  405.                     {
  406.                         outHeader = (BlockHeader*) walker;
  407.                         
  408.                     }
  409.                     else
  410.                         fErr = kBadMarker1;
  411.                     
  412.                     break;
  413.                 }
  414.                 else
  415.                 if(CharPtrToLong(walker) == kMarker1)
  416.                 {
  417.                     // whoo hoo! We found the headMarker.
  418.                 
  419.                     outHeader = (BlockHeader*) walker;
  420.  
  421.                     if(outHeader->fMarker2 != kMarker2)
  422.                     {
  423.                         outHeader = NULL;
  424.                     }
  425.                     else
  426.                         fErr = kBadMarker2;
  427.                         
  428.                     break;
  429.                 }
  430.                 
  431.             
  432.             }
  433.             
  434.             if(!outHeader && !fErr)
  435.             {
  436.                 fErr = kNoMarkersFound; // yikes!
  437.             }
  438.             
  439.         #if qDebugTidyHeap    
  440.             if(outHeader)
  441.             {
  442.                 long offset = ((char*)outHeader) - inPtr;
  443.                 Logf("### Had to search header for markers. Found the offset at %d", offset);
  444.             }
  445.         #endif    
  446.         
  447.         
  448.         } // else
  449.  
  450.     }    
  451.  
  452.     if(fErr)
  453.         LogError();
  454.     
  455.     return outHeader;
  456. }
  457.  
  458. //----------------------------------------------------------------------------------------
  459. // CTidyHeap_AC::LogError
  460. //----------------------------------------------------------------------------------------
  461.  
  462. void CTidyHeap_AC::LogError()
  463. {
  464.  
  465.     const char* descStr;
  466.     
  467.     switch(fErr)
  468.     {
  469.         // Should probably load these strings from a resource.
  470.         
  471.         case kNoErr:
  472.             descStr = "No Error";
  473.             break;
  474.         
  475.         case kBadMarker1:
  476.             descStr = "Bad Block Header: Marker 1 corrupt";
  477.             break;
  478.         
  479.         case kBadMarker2:
  480.             descStr = "Bad Block Header: Marker 2 corrupt";
  481.             break;
  482.         
  483.         case kBadMarker3:
  484.             descStr = "Bad Block Trailer: Marker 1 corrupt";
  485.             break;
  486.  
  487.         case kNoMarkersFound:
  488.             descStr = "Found no markers at all! (Yikes!)";
  489.             break;
  490.         
  491.         case kPtrCrossRefFailed:
  492.             descStr = "Pointer Cross Reference failed.";
  493.             break;
  494.         
  495.         case kPtrNotInAppHeap:
  496.             descStr = "Block not in Application Heap.";
  497.             break;
  498.         
  499.         default:
  500.             descStr = "Invalid Error value. Run for your life!";
  501.             break;
  502.     
  503.     }
  504.     
  505.     if(GetFeaturePrefs().TestFlag(kWarnings))
  506.     {
  507.         Warnf("TidyHeap Error: %s (%d)", descStr, fErr );
  508.     }
  509.  
  510.     Logf("### TidyHeap Error: %s (%d)", descStr, fErr );
  511. }
  512.  
  513. //----------------------------------------------------------------------------------------
  514. // CTidyHeap_AC::RemoveBlock
  515. //----------------------------------------------------------------------------------------
  516.  
  517. void CTidyHeap_AC::RemoveBlock(void* ptr)
  518. {
  519.     if(!IsEnabled())
  520.         GlobalDelete(ptr);
  521.     else
  522.     {
  523.         fDeleteCount++;
  524.         
  525.         fErr = 0;
  526.         
  527.         // This will log an error if it fails.
  528.         BlockHeader* toDelete = FindHeader((char*) ptr);
  529.             
  530.         if(toDelete && !fErr)
  531.         {
  532.             BlockTrailer* trailer = FindTrailer(toDelete);
  533.         
  534.             CTidyHeapBlock_AC* blockPtr = toDelete->fBlockPtr;
  535.             
  536.             if(trailer && !fErr)
  537.             {
  538.                 CTidyHeapAction_AC* action = fDeleteActions.GetHead();
  539.                 
  540.                 while(action)
  541.                 {
  542.                     DoAction( action, toDelete);
  543.                     action = action->Next();
  544.                 }
  545.                 
  546.                 CTidyHeapAction_AC* deleteAction = toDelete->fBlockPtr->fDeleteAction;
  547.                 
  548.                 if(deleteAction)
  549.                 {
  550.                     DoAction( deleteAction, toDelete);
  551.                     
  552.                     delete deleteAction;            
  553.                     toDelete->fBlockPtr->fDeleteAction = NULL;
  554.                 }        
  555.                 
  556.                 if(blockPtr->fFlags.TestFlag(CTidyHeapBlock_AC::kDeleted))
  557.                 {
  558.                     Logf("### Block Double Delete detected!");
  559.                     Warnf("Block Double Delete detected!");
  560.                     // add more here
  561.                 }
  562.                 else
  563.                 {
  564.                     blockPtr->fFlags.SetFlag(CTidyHeapBlock_AC::kDeleted, true);
  565.                     
  566.                     if(!blockPtr->fFlags.TestFlag(CTidyHeapBlock_AC::kDontDelete))
  567.                     {
  568.                         fBlockList.Remove(blockPtr);
  569.         
  570.                         GlobalDelete((char*)toDelete);
  571.                         
  572.                         delete blockPtr;
  573.                     }
  574.                 }
  575.             }
  576.         }
  577.     }
  578. }
  579.  
  580. //----------------------------------------------------------------------------------------
  581. // CTidyHeap_AC::PushInfo
  582. //----------------------------------------------------------------------------------------
  583.  
  584. void CTidyHeap_AC::PushInfo(const char* file, short lineNum)
  585. {
  586.     fgSelf->fLineNum = lineNum;
  587.     ::strcpy(fgSelf->fFileName, file);
  588. }
  589.  
  590. //----------------------------------------------------------------------------------------
  591. // CTidyHeap_AC::Instance
  592. //----------------------------------------------------------------------------------------
  593.  
  594. CTidyHeap_AC* CTidyHeap_AC::Instance()
  595. {
  596.     static Boolean firstTime = true;
  597.     
  598.     if(firstTime)
  599.     {
  600.         firstTime = false;
  601.  
  602.         CTidyHeap_AC::GlobalNew = (GlobalNewProc) NewPtr;
  603.         CTidyHeap_AC::GlobalDelete = (GlobalDeleteProc) DisposePtr;    
  604.             
  605.         fgSelf = CreateTidyHeap();
  606.         if( !fgSelf )
  607.         {    
  608.             DebugStr("\pUnable to allocate TidyHeap. Something is seriously wrong.");
  609.             ExitToShell();
  610.         }
  611.         fgSelf->ITidyHeap();    
  612.     }
  613.     
  614.     return fgSelf;
  615. }
  616.  
  617. //----------------------------------------------------------------------------------------
  618. // CTidyHeap_AC::Terminate
  619. //----------------------------------------------------------------------------------------
  620.  
  621. void CTidyHeap_AC::Terminate()
  622. {
  623.     if(fgSelf)
  624.     {
  625.         fgSelf->HandleTermination();
  626.             
  627.         delete fgSelf;
  628.         fgSelf = NULL;
  629.  
  630. #if qDebugTidyHeap        
  631.         char str[100];
  632.         
  633.         if(MTidyHeapAllocator_AC::fgAllocationCounter > 0)
  634.         {
  635.             sprintf(str, "Number of TidyHeap's Leaks: %ld;g", MTidyHeapAllocator_AC::fgAllocationCounter);
  636.             c2pstr(str);
  637.             DebugStr((StringPtr)str);
  638.         }
  639. #endif
  640.     }
  641.     
  642. }
  643.  
  644.  
  645. //----------------------------------------------------------------------------------------
  646. // CTidyHeap_AC::Logf
  647. //----------------------------------------------------------------------------------------
  648.  
  649. void CTidyHeap_AC::Logf(const char* format, ...)
  650. {
  651.     if(IsEnabled() && fLogger)
  652.     {
  653.         static va_list args;
  654.         
  655.         va_start(args, format);
  656.         vsprintf(fLogString, format, args);
  657.         va_end(args);
  658.         
  659.         fLogger->Log(fLogString);
  660.     }
  661. }
  662.  
  663. //----------------------------------------------------------------------------------------
  664. // CTidyHeap_AC::Warnf
  665. //----------------------------------------------------------------------------------------
  666.  
  667. void CTidyHeap_AC::Warnf(const char* format, ...)
  668. {
  669.     static va_list args;
  670.     
  671.     if(IsEnabled() && GetWantsWarnings())
  672.     {
  673.         va_start(args, format); // can't globally scope
  674.         ::vsprintf(fLogString, format, args);
  675.         va_end(args); // can't globally scope
  676.     
  677.         ::c2pstr(fLogString);
  678.         
  679.         ::DebugStr((unsigned char*) fLogString);
  680.     }
  681. }
  682.     
  683. //----------------------------------------------------------------------------------------
  684. // CTidyHeap_AC::VerifyAllBlocks
  685. //----------------------------------------------------------------------------------------
  686.  
  687. void CTidyHeap_AC::VerifyAllBlocks(Boolean logBlockData)
  688. {
  689.     if(IsEnabled())
  690.     {
  691.         long size = 0;
  692.         if(!fBlockList.IsEmpty())
  693.         {
  694.             CTidyHeapBlock_AC* walker = fBlockList.GetHead();
  695.             
  696.             while(walker)
  697.             {
  698.                 
  699.                 VerifyBlock( walker->fAddress, logBlockData );
  700.                 size += walker->fSize;
  701.                 
  702.                 walker = walker->Next();
  703.             }
  704.             
  705.             Logf("### Sum of outstanding block sizes = %ld bytes.", size );
  706.         }
  707.     }
  708. }
  709.  
  710. //----------------------------------------------------------------------------------------
  711. // CTidyHeap_AC::VerifyBlock
  712. //----------------------------------------------------------------------------------------
  713.  
  714. CTidyHeapError_AC CTidyHeap_AC::VerifyBlock(void* inBlock, Boolean logBlockData)
  715. {
  716.     if(IsEnabled())
  717.     {
  718.         CTidyHeapBlock_AC* block = 0;
  719.         BlockHeader* header = FindHeader((char*) inBlock);
  720.         BlockTrailer* trailer = NULL;
  721.             
  722.         if(header && !fErr)
  723.             trailer = FindTrailer(header);
  724.  
  725.         if(!fErr)
  726.         {
  727.             block = header->fBlockPtr;
  728.             
  729.             if(    (block->fAddress != inBlock) || (block->fHeader != header))
  730.             {
  731.                 fErr = kPtrCrossRefFailed;
  732.             }
  733.             else
  734.             if( logBlockData )
  735.                 block->LogBlockData();
  736.         }
  737.  
  738.         if(fErr)
  739.         {
  740.             // already logged the error in FindHeader or FindTrailer
  741.             if(block) block->LogBlockData();    
  742.         }
  743.     }
  744.         
  745.     return fErr;
  746. }
  747.  
  748. //----------------------------------------------------------------------------------------
  749. // CTidyHeap_AC::SetDebugStrHook
  750. //----------------------------------------------------------------------------------------
  751.  
  752. void CTidyHeap_AC::SetToDebugStrLogger( Boolean doHalt)
  753. {
  754.     AquireLogger( new CTidyHeapDebugStrLogger_AC(doHalt) );
  755. }
  756.  
  757. //----------------------------------------------------------------------------------------
  758. // CTidyHeap_AC::SetLogFileHook
  759. //----------------------------------------------------------------------------------------
  760.  
  761. void CTidyHeap_AC::SetToLogFileLogger()
  762. {
  763.     AquireLogger( new CTidyHeapLogFileLogger_AC );
  764. }
  765.  
  766. //----------------------------------------------------------------------------------------
  767. // CTidyHeap_AC::VerifyState
  768. //----------------------------------------------------------------------------------------
  769.  
  770. long CTidyHeap_AC::VerifyState(CTidyHeapState_AC &inShot)
  771. {
  772.     long count = 0;
  773.     
  774.     if(IsEnabled())
  775.     {
  776.         BlockHeader* marker = FindHeader( (char*) inShot.fMarker );
  777.         
  778.         if( marker->fBlockPtr != fBlockList.GetTail())
  779.         {
  780.             Logf("### Warning: outstanding blocks remaining after state saved.");
  781.             
  782.             CTidyHeapBlock_AC* walker = marker->fBlockPtr->Next();
  783.             
  784.             while(walker)
  785.             {
  786.                 VerifyBlock( walker->fAddress );
  787.                 count++;
  788.                 walker = walker->Next();
  789.             }
  790.             
  791.             Logf("### Num new blocks since state saved: %ld", count);
  792.         }
  793.         else
  794.         {
  795.             Logf("### State detected no leaks.");
  796.         }
  797.     }
  798.     
  799.     return count;
  800. }
  801.  
  802. //----------------------------------------------------------------------------------------
  803. // CTidyHeap_AC::DeleteActions
  804. //----------------------------------------------------------------------------------------
  805.  
  806. void CTidyHeap_AC::DeleteActions( CTidyHeapActionList_AC &inList )
  807. {
  808.     // Note:this should be a list method.
  809.     
  810.     CTidyHeapAction_AC* walker = inList.GetHead();
  811.     CTidyHeapAction_AC* deleter = NULL;
  812.     
  813.     while(walker)
  814.     {
  815.         deleter = walker;
  816.         walker = walker->Next();
  817.     
  818.         if(deleter) 
  819.         {
  820.             inList.Remove(deleter);
  821.             delete deleter;    
  822.         }
  823.     }
  824.  
  825. }
  826.  
  827. //----------------------------------------------------------------------------------------
  828. // CTidyHeap_AC::DoAction
  829. //----------------------------------------------------------------------------------------
  830.  
  831. void CTidyHeap_AC::DoAction( CTidyHeapAction_AC* action, BlockHeader* header)
  832. {
  833.     if(header)
  834.     {
  835.         action->DoAction(header->fBlockPtr);
  836.     }
  837.     else
  838.     {
  839.         action->DoAction(NULL);
  840.     }
  841. }
  842.  
  843.  
  844.  
  845. //----------------------------------------------------------------------------------------
  846. // CTidyHeap_AC::GetBlock
  847. //----------------------------------------------------------------------------------------
  848.  
  849. CTidyHeapBlock_AC* CTidyHeap_AC::GetBlock(void* inPtr)
  850. {
  851.     
  852.     CTidyHeapBlock_AC* outBlock = NULL;
  853.     
  854.     if(IsEnabled())
  855.     {
  856.         fErr = 0;
  857.         
  858.         
  859.         BlockHeader* header = FindHeader((char*) inPtr);
  860.         if(header)
  861.         {
  862.             outBlock = header->fBlockPtr;
  863.         }
  864.     }    
  865.     return outBlock;
  866. }
  867.  
  868. //----------------------------------------------------------------------------------------
  869. // CTidyHeap_AC::GetMarker
  870. //----------------------------------------------------------------------------------------
  871.  
  872. CTidyHeapMarker_AC CTidyHeap_AC::GetMarker( void* inPtr, short markerNum )
  873. {
  874.     fErr = 0;
  875.     CTidyHeapMarker_AC outMarker = 0xF0F0F0F0;
  876.     
  877.     if(IsEnabled())
  878.     {
  879.         BlockHeader* header = FindHeader((char*)inPtr);
  880.         if(header)
  881.         {
  882.             switch( markerNum )
  883.             {
  884.                 case 1:
  885.                     outMarker = header->fMarker1;
  886.                     break;
  887.                 
  888.                 case 2:
  889.                     outMarker = header->fMarker2;
  890.                     break;
  891.                 
  892.                 case 3:
  893.                     BlockTrailer* trailer = FindTrailer(header);
  894.                     if(!fErr)
  895.                     {
  896.                         outMarker = trailer->fMarker3;
  897.                     }    
  898.                 
  899.                     break;
  900.             
  901.             }    
  902.         }
  903.     }
  904.     return outMarker;
  905. }
  906.  
  907. //----------------------------------------------------------------------------------------
  908. // CTidyHeap_AC::CreateBlockObject
  909. //----------------------------------------------------------------------------------------
  910.  
  911. CTidyHeapBlock_AC* CTidyHeap_AC::CreateBlockObject()
  912. {
  913.     return new CTidyHeapBlock_AC;
  914. }
  915.  
  916. //----------------------------------------------------------------------------------------
  917. // CTidyHeap_AC::MakeNextNewFail
  918. //----------------------------------------------------------------------------------------
  919.  
  920. void CTidyHeap_AC::MakeNextNewFail()
  921. {
  922.     fNextNewFails = true;
  923. }
  924.  
  925. //----------------------------------------------------------------------------------------
  926. // CTidyHeap_AC::AquireNewAction
  927. //----------------------------------------------------------------------------------------
  928.  
  929. void CTidyHeap_AC::AquireNewAction( CTidyHeapAction_AC* inAction )
  930. {
  931.     fNewActions.Append(inAction);
  932. }
  933.  
  934. //----------------------------------------------------------------------------------------
  935. // CTidyHeap_AC::RemoveNewAction
  936. //----------------------------------------------------------------------------------------
  937.  
  938. void CTidyHeap_AC::RemoveNewAction( CTidyHeapAction_AC* inAction)
  939. {
  940.     fNewActions.Remove(inAction);
  941. }
  942.  
  943.  
  944. //----------------------------------------------------------------------------------------
  945. // CTidyHeap_AC::AquireDeleteAction
  946. //----------------------------------------------------------------------------------------
  947.  
  948. void CTidyHeap_AC::AquireDeleteAction( CTidyHeapAction_AC* inAction)
  949. {
  950.     fDeleteActions.Append(inAction);
  951. }
  952.  
  953. //----------------------------------------------------------------------------------------
  954. // CTidyHeap_AC::RemoveDeleteAction
  955. //----------------------------------------------------------------------------------------
  956.  
  957. void CTidyHeap_AC::RemoveDeleteAction( CTidyHeapAction_AC* inAction )
  958. {
  959.     fDeleteActions.Remove(inAction);
  960. }
  961.  
  962. //----------------------------------------------------------------------------------------
  963. // CTidyHeap_AC::AquireTerminationAction
  964. //----------------------------------------------------------------------------------------
  965.  
  966. void CTidyHeap_AC::AquireTerminationAction( CTidyHeapAction_AC* inAction )
  967. {
  968.     fTerminationActions.Append(inAction);
  969. }
  970.  
  971. //----------------------------------------------------------------------------------------
  972. // CTidyHeap_AC::RemoveTerminationAction
  973. //----------------------------------------------------------------------------------------
  974.  
  975. void CTidyHeap_AC::RemoveTerminationAction( CTidyHeapAction_AC* inAction)
  976. {
  977.     fTerminationActions.Remove(inAction);
  978. }
  979.  
  980. //----------------------------------------------------------------------------------------
  981. // CTidyHeap_AC::GetTerminationActionList
  982. //----------------------------------------------------------------------------------------
  983.  
  984. CTidyHeapActionList_AC& CTidyHeap_AC::GetTerminationActionList()
  985. {
  986.     return fTerminationActions;
  987. }
  988.  
  989. //----------------------------------------------------------------------------------------
  990. // CTidyHeap_AC::GetNewActionsList
  991. //----------------------------------------------------------------------------------------
  992.  
  993. CTidyHeapActionList_AC& CTidyHeap_AC::GetNewActionsList()
  994. {
  995.     return fNewActions;
  996. }
  997.     
  998. //----------------------------------------------------------------------------------------
  999. // CTidyHeap_AC::GetDeleteActionList
  1000. //----------------------------------------------------------------------------------------
  1001.  
  1002. CTidyHeapActionList_AC& CTidyHeap_AC::GetDeleteActionList()
  1003. {
  1004.     return fDeleteActions;
  1005. }
  1006.  
  1007. //----------------------------------------------------------------------------------------
  1008. // CTidyHeap_AC::IsEnabled
  1009. //----------------------------------------------------------------------------------------
  1010.  
  1011. Boolean CTidyHeap_AC::IsEnabled() const
  1012. {
  1013.     return fEnabledOnStart;
  1014. }
  1015.  
  1016. //----------------------------------------------------------------------------------------
  1017. // CTidyHeap_AC::SetIsEnabled
  1018. //----------------------------------------------------------------------------------------
  1019.  
  1020. void CTidyHeap_AC::SetIsEnabled(Boolean isEnabled)
  1021. {
  1022.     CTidyHeapSettings_AC::SetIsEnabled(isEnabled);
  1023. }
  1024.  
  1025. //----------------------------------------------------------------------------------------
  1026. // CTidyHeap_AC::AquireLogger
  1027. //----------------------------------------------------------------------------------------
  1028.  
  1029.  CTidyHeapLogger_AC * CTidyHeap_AC::AquireLogger( CTidyHeapLogger_AC *inLogger, Boolean deletePrevious)
  1030. {
  1031.     CTidyHeapLogger_AC *outLogger = NULL;
  1032.  
  1033.     if(fLogger)
  1034.     {
  1035.         if(deletePrevious)
  1036.             delete fLogger;
  1037.         else
  1038.             outLogger = fLogger;
  1039.     }
  1040.         
  1041.     fLogger = inLogger;
  1042.  
  1043.     return outLogger;
  1044. }
  1045.  
  1046. //----------------------------------------------------------------------------------------
  1047. // CTidyHeap_AC::RemoveAllActions
  1048. //----------------------------------------------------------------------------------------
  1049.  
  1050. void CTidyHeap_AC::RemoveAllActions()
  1051. {
  1052.     DeleteActions( fNewActions );
  1053.     DeleteActions( fDeleteActions );
  1054. }
  1055.  
  1056. //----------------------------------------------------------------------------------------
  1057. // CTidyHeap_AC::InstallPrefActions
  1058. //----------------------------------------------------------------------------------------
  1059.  
  1060. void CTidyHeap_AC::InstallPrefActions()
  1061. {
  1062.     for(short i = 0; i < kNumActions; i++)
  1063.     {
  1064.         switch(i)
  1065.         {
  1066.             case kDoubleDeleteWatcher:
  1067.                 if( fActions.TestFlag(i) )
  1068.                     AquireDeleteAction( new CActionDoubleDeleteWatcher_AC );
  1069.                 break;
  1070.             
  1071.             case kMakeNewFail:
  1072.                 if( fActions.TestFlag(i) )
  1073.                     AquireNewAction( new CActionMakeNewFail_AC(fNewFailCount) );
  1074.                 break;
  1075.             
  1076.             case kIncrementalFailer:
  1077.                 if( fActions.TestFlag(i) )
  1078.                     AquireNewAction(  new CActionIncrementalNewFailer_AC ); 
  1079.                 break;
  1080.             
  1081.             case kNewVerifyAction:
  1082.                 if( fActions.TestFlag(i) )
  1083.                     AquireNewAction( new CActionVerifyBlock_AC ); 
  1084.                 break;
  1085.             
  1086.             case kDeleteVerifyAction:
  1087.                 if( fActions.TestFlag(i) )
  1088.                     AquireDeleteAction( new CActionVerifyBlock_AC ); 
  1089.                 break;
  1090.             
  1091.             case kNewVerifyAllAction:
  1092.                 if( fActions.TestFlag(i) )
  1093.                     AquireNewAction(new CActionVerifyAll_AC ); 
  1094.                 break;
  1095.  
  1096.             case kDeleteVerifyAllAction:
  1097.                 if( fActions.TestFlag(i) )
  1098.                     AquireDeleteAction(new CActionVerifyAll_AC ); 
  1099.                 break;
  1100.                 
  1101.             case kExemptUnknownBlocks:
  1102.                 if( fActions.TestFlag(i) )
  1103.                     AquireNewAction(new CActionExcemptUnknownBlocks_AC ); 
  1104.                 break;
  1105.             
  1106.             case kGarbageIn:
  1107.                 if( fActions.TestFlag(i) )
  1108.                     AquireNewAction(new CActionGarbageIn_AC ); 
  1109.                 break;
  1110.             
  1111.             case kGarbageOut:
  1112.                 if( fActions.TestFlag(i) )
  1113.                     AquireDeleteAction(new CActionGarbageOut_AC ); 
  1114.                 break;
  1115.                 
  1116.             case kNewBreakOnUnknownBlock:
  1117.                 if( fActions.TestFlag(i) )
  1118.                     AquireNewAction(new CActionBreakOnUnknownBlock_AC ); 
  1119.                 break;
  1120.             
  1121.             case kDeleteBreakOnUnknownBlock:
  1122.                 if( fActions.TestFlag(i) )
  1123.                     AquireDeleteAction(new CActionBreakOnUnknownBlock_AC ); 
  1124.                 break;
  1125.         }
  1126.     }
  1127. }
  1128.  
  1129. //----------------------------------------------------------------------------------------
  1130. // CTidyHeap_AC::GetSessionFileLoc
  1131. //----------------------------------------------------------------------------------------
  1132.  
  1133. void CTidyHeap_AC::GetSessionFileLoc(short& vol, long &dirId)
  1134. {
  1135.     vol = 0;
  1136.     dirId = 0;
  1137. }
  1138.  
  1139. //----------------------------------------------------------------------------------------
  1140. // CTidyHeap_AC::HandleNilAllocation
  1141. //----------------------------------------------------------------------------------------
  1142.  
  1143. void CTidyHeap_AC::HandleNilAllocation()
  1144. {
  1145.     // override this if you want to throw an exception or something.
  1146.     
  1147. }
  1148.  
  1149. //----------------------------------------------------------------------------------------
  1150. // CTidyHeap_AC::GetErr
  1151. //----------------------------------------------------------------------------------------
  1152.  
  1153. CTidyHeapError_AC CTidyHeap_AC::GetErr()
  1154. {
  1155.     return fErr;
  1156. }
  1157.  
  1158. //----------------------------------------------------------------------------------------
  1159. // CTidyHeap_AC::GetBlockList
  1160. //----------------------------------------------------------------------------------------
  1161.  
  1162. CTidyHeapBlockList_AC& CTidyHeap_AC::GetBlockList()
  1163. {
  1164.     return fBlockList;
  1165. }
  1166.  
  1167. //----------------------------------------------------------------------------------------
  1168. // CTidyHeap_AC::PtrInAppHeap
  1169. //----------------------------------------------------------------------------------------
  1170.  
  1171. Boolean CTidyHeap_AC::PtrInAppHeap(void* inPtr)
  1172. {
  1173.     THz appZone = ::LMGetApplZone();
  1174.     return inPtr >= &(appZone->heapData) && inPtr < appZone->bkLim;
  1175. }
  1176.  
  1177. //----------------------------------------------------------------------------------------
  1178. // CTidyHeap_AC::HandleTermination
  1179. //----------------------------------------------------------------------------------------
  1180.  
  1181. void CTidyHeap_AC::HandleTermination()
  1182. {
  1183.     if(IsEnabled())
  1184.     {
  1185.         Logf("### TidyHeap Termination Messages:");
  1186.         
  1187.         Logf("### %d Outstanding blocks, %ld total blocks, Ave Size %f",
  1188.             GetBlockCount(), 
  1189.             GetBlockCountTally(),
  1190.             GetAveSize() );
  1191.         
  1192.         Logf("### New called %d times, Delete called %d times",
  1193.              GetBlockCountTally(),
  1194.              fDeleteCount);
  1195.     
  1196.         if(    GetFeaturePrefs().TestFlag( CTidyHeapSettings_AC::kUndeletedBlockWarning ) &&
  1197.             GetBlockCount())
  1198.             Warnf("TidyHeap Warning: you have %ld undeleted blocks.;g", GetBlockCount() );
  1199.         
  1200.         if(    GetFeaturePrefs().TestFlag( CTidyHeapSettings_AC::kLogUndeletedBlocks ) )
  1201.         {
  1202.             VerifyAllBlocks(true); // true means log the block data
  1203.         }
  1204.         
  1205.         CTidyHeapAction_AC* actionWalker = fTerminationActions.GetHead();
  1206.         
  1207.         while(actionWalker)
  1208.         {
  1209.             DoAction(actionWalker, NULL);
  1210.             actionWalker = actionWalker->Next();
  1211.         }
  1212.  
  1213.     }
  1214.  
  1215. }
  1216.  
  1217. //----------------------------------------------------------------------------------------
  1218. // CTidyHeap_AC::ExemptBlockFromLeakCheck
  1219. //----------------------------------------------------------------------------------------
  1220.  
  1221. void CTidyHeap_AC::ExemptBlockFromLeakCheck(void* inBlock)
  1222. {
  1223.     CTidyHeapBlock_AC* theBlock = Instance()->GetBlock(inBlock);
  1224.     if(theBlock)
  1225.     {
  1226.         theBlock->SetExempt(true);
  1227.     }
  1228. }
  1229.  
  1230.  
  1231.  
  1232. #endif